package DynamicArr;

import java.util.Arrays;

public class MyArray {
    /**
     * 基于数组的顺序表
     */
    private int[] data;
    private int size;

    //默认构建10的初始数组
    public MyArray() {
        int[] data = new int[10];
    }

    //用户定义初始数组
    public MyArray(int num) {
        data = new int[num];
    }

    @Override
    public String toString() {
        String ret = "[";
        for (int i = 0; i < size; i++) {
            ret += data[i];
            if (i != size - 1)
                ret += ",";
        }
        ret += "]";
        return ret;
    }

    //判断是否扩充数组
    private void grow() {
        int[] newdata = Arrays.copyOf(this.data, this.data.length << 1);
        this.data = newdata;
    }

    /**
     * add数组的增操作
     * addFirst(int value)
     * addLast(int value)
     * addIndex(int index,int value)
     */
    //从首部增加
    public void addFirst(int value) {
        addIndex(0, value);
    }

    //从中间索引增加
    public void addIndex(int index, int value) {
        if (size == data.length) {
            grow();
        }
        if (index < 0 || index > size) {
            System.out.println("Erros!!!");
            return;
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = value;
        size++;
    }

    //从尾部增加
    public void addLast(int value) {
        addIndex(size, value);
    }

    /**
     * 数组删除
     * removeFirst()删除头元素
     * removeIndex(int index)根据索引删除
     * removeLast()删除尾元素
     * removeValueOnce(int value)删除第一次出现的该元素值
     * removeAllValue(int value)删除所有此元素
     */
    //删除第一次出现的该元素值
    public void removeValueOnce(int value) {
        for (int i = 0; i < size; i++) {
            if (data[i] == value) {
                removeIndex(i);
                return;
            }
        }
        System.out.println("不存在此元素");
    }

    //删除所有此元素
    public void removeAllValue(int value) {
        for (int i = 0; i < size; i++) {
            //存在连续存在相同的元素
            while (i != size && data[i] == value) {
                removeIndex(i);
            }
        }
    }

    //删除头元素
    public void removeFirst() {
        removeIndex(0);
    }

    //根据索引删除元素
    public void removeIndex(int index) {
        if (index < 0 || index > size - 1) {
            System.out.println("Erros!!!");
            return;
        }
        for (int i = index; i < size - 1; i++) {
            data[i] = data[i + 1];
        }
        size--;
        data[size] = 0;
    }

    //删除尾部元素
    public void removeLast() {
        removeIndex(size - 1);
    }

    /**
     * 元素的查找
     * boolean contains(int value)查找元素是否存在
     * int get(int index)根据索引获取元素
     * int getByValue(int value)查找元素的下标
     */
    //boolean contains(int value)查找元素是否存在
    public boolean contains(int value) {
        int flag = getByValue(value);
        return flag != -1;
    }

    //int get(int index)根据索引获取元素
    public int get(int index) {
        if (index < 0 || index > size - 1) {
            System.out.println("Erros!!!");
            return -1;
        }
        return data[index];
    }

    //int getByValue(int value)查找元素的下标
    public int getByValue(int value) {
        for (int i = 0; i < size; i++) {
            if (data[i] == value)
                return i;
        }
        return -1;
    }

    /**
     * 元素的修改
     * int set(int index , int newValue)
     * 将指定索引位置的元素修改，返回修改前的元素值
     */
    public int set(int index, int newValue) {
        if (index < 0 || index > size - 1) {
            System.out.println("Erros!!!");
            return -1;
        }
        int oldValue = data[index];
        data[index] = newValue;
        return oldValue;
    }
}

